//package Hot100.leetcode.editor.cn.code.面试;
//
//import java.util.ArrayList;
//import java.util.List;
//
////这个类实现了两个基本的字符串操作功能：
////split 方法：将字符串按照指定分隔符拆分成字符串数组
////join 方法：将字符串数组按照指定分隔符合并成一个字符串
////这类似于Java标准库中的 String.split() 和 String.join() 方法的自实现版本。
//    public class StringSplitter {
//        /**
//         * 字符串拆分成数组
//         * @param str 原始字符串
//         * @param delimiter 分隔符
//         * @return 拆分后的字符串数组
//         */
//        public static String[] split(String str, String delimiter) {
//            // 计算分隔符出现的次数
//            int count = 0;
//            int startIndex = 0;
//            while ((startIndex = indexOf(str, delimiter, startIndex)) != -1) {
//                count++;
//                startIndex += delimiter.length();
//            }
//
//            // 创建结果数组
//            String[] result = new String[count + 1];
//
//            // 填充结果数组
//            startIndex = 0;
//            for (int i = 0; i < count; i++) {
//                //分割符的起始位置作为内容的结束位置
//                int endIndex = indexOf(str, delimiter, startIndex);
//                result[i] = substring(str, startIndex, endIndex);
//                startIndex = endIndex + delimiter.length();
//            }
//
//            // 处理最后一部分
//            result[count] = substring(str, startIndex, str.length());
//
//            return result;
//        }
//
//        /**
//         * 实现字符串组合
//         * @param array 字符串数组
//         * @param delimiter 分隔符
//         * @return 组合后的字符串
//         */
//        public static String join(String[] array, String delimiter) {
//            if (array == null || array.length == 0) {
//                return "";
//            }
//
//            StringBuilder sb = new StringBuilder();
//            sb.append(array[0]);
//
//            for (int i = 1; i < array.length; i++) {
//                sb.append(delimiter);
//                sb.append(array[i]);
//            }
//
//            return sb.toString();
//        }
//
//        /**
//         * 查找子字符串在指定位置之后首次出现的位置
//         * @param str 主字符串
//         * @param target 要查找的子字符串
//         * @param fromIndex 起始查找位置
//         * @return 子字符串首次出现的位置，未找到返回-1
//         */
//        private static int indexOf(String str, String target, int fromIndex) {
//            if (fromIndex < 0) {
//                fromIndex = 0;
//            }
//
//            int maxIndex = str.length() - target.length();
//            for (int i = fromIndex; i <= maxIndex; i++) {
//                boolean found = true;
//                for (int j = 0; j < target.length(); j++) {
//                    if (str.charAt(i + j) != target.charAt(j)) {
//                        found = false;
//                        break;
//                    }
//                }
//                if (found) {
//                    return i;
//                }
//            }
//            return -1;
//        }
//
//        /**
//         * 截取子字符串
//         * @param str 原始字符串
//         * @param beginIndex 起始索引（包含）
//         * @param endIndex 结束索引（不包含）
//         * @return 截取的子字符串
//         */
//        private static String substring(String str, int beginIndex, int endIndex) {
//            if (beginIndex > endIndex || beginIndex < 0 || endIndex > str.length()) {
//                throw new StringIndexOutOfBoundsException();
//            }
//
//            char[] chars = new char[endIndex - beginIndex];
//            for (int i = beginIndex; i < endIndex; i++) {
//                chars[i - beginIndex] = str.charAt(i);
//            }
//            return new String(chars);
//        }
//    }
////这个算法解决的问题是：
////在一个包含1001个元素的数组中，包含了0到999的所有整数，其中有一个数字重复出现了。找出这个重复的数字。
//    public class FindDuplicate {
//        public static int findDuplicate(int[] numbers) {
//            // 0到999的所有数字异或一遍
//            int xorAll = 0;
//            for (int i = 0; i <= 999; i++) {
//                xorAll ^= i;
//            }
//
//            // 将所有输入数字异或一遍
//            int xorNumbers = 0;
//            for (int number : numbers) {
//                xorNumbers ^= number;
//            }
//
//            // 两个异或结果再异或，得到重复的数字
//            // 因为除了重复的数字外，其他数字都出现了两次，会被抵消
//            return xorAll ^ xorNumbers;
//        }
//    }
//    //生成26个英文字母的所有非空子集组合
//    public class LetterCombinations {
//        public static List<String> generateCombinations() {
//            List<String> result = new ArrayList<>();
//            char[] letters = new char[26];
//
//            // 初始化26个字母
//            for (int i = 0; i < 26; i++) {
//                letters[i] = (char) ('a' + i);
//            }
//
//            // 使用位运算生成所有组合
//            // 从1到2^26-1的每个数字代表一种组合
//            for (int i = 1; i < (1 << 26); i++) {
//                StringBuilder sb = new StringBuilder();
//                for (int j = 0; j < 26; j++) {
//                    // 检查第j位是否为1
//                    if ((i & (1 << j)) != 0) {
//                        sb.append(letters[j]);
//                    }
//                }
//                result.add(sb.toString());
//            }
//
//            return result;
//        }
//    }
////使用两个线程交替打印数字，一个线程打印偶数，另一个线程打印奇数，按顺序输出0到200
//    public class ThreadPrint {
//        private static final Object lock = new Object();
//        private static int count = 0;
//        private static final int MAX_COUNT = 200;
//
//        public static void main(String[] args) {
//            //打印偶数
//            Thread thread1 = new Thread(() -> {
//                while (count <= MAX_COUNT) {
//                    synchronized (lock) {
//                        // 如奇，等待
//                        while (count % 2 == 1 && count <= MAX_COUNT) {
//                            try {
//                                lock.wait();
//                            } catch (InterruptedException e) {
//                                Thread.currentThread().interrupt();
//                            }
//                        }
//
//                        if (count <= MAX_COUNT) {
//                            System.out.println("Thread1: " + count);
//                            count++;
//                            lock.notifyAll();
//                        }
//                    }
//                }
//            });
//
//            //打印奇数
//            Thread thread2 = new Thread(() -> {
//                while (count <= MAX_COUNT) {
//                    synchronized (lock) {
//                        // 如偶，等待
//                        while (count % 2 == 0 && count <= MAX_COUNT) {
//                            try {
//                                lock.wait();
//                            } catch (InterruptedException e) {
//                                Thread.currentThread().interrupt();
//                            }
//                        }
//
//                        if (count <= MAX_COUNT) {
//                            System.out.println("Thread2: " + count);
//                            count++;
//                            lock.notifyAll();
//                        }
//                    }
//                }
//            });
//
//            thread1.start();
//            thread2.start();
//        }
//    }
